# 初始

"""
1. 创建一个列表`list1`，其包含元素 1, 2, 3, 4, 5。
"""
# list1 = [1,2,3,4,5]
# print(list1)
"""
2. 向`list1` 添加一个元素 6
"""
# list1.append(6)
# print(list1)
"""
3. 从`list1` 中删除元素 3。
"""
# list1.remove(3)
# print(list1)
"""
4. 修改`list1` 中的第二个元素值为 8。
"""
# list1[1] = 8
# print(list1)
"""
5. 找出`list1` 中值为 8 的元素索引。
"""
# print(list1.index(8))
"""
6. 遍历`list1`，打印每个元素的值。
"""
# for i in list1:
#     print(i)
"""
7. 利用循环，将一个新列表 `7, 8, 9]` 的每个元素添加到`list1` 的末尾。
"""
# new_list = [7,8,9]
# for i in new_list:
#     list1.append(i)
# print(list1)

"""
8.使用一个命令，将列表 `10, 11, 12]` 添加到`list1` 的末尾
"""
# list2 = [10,11,12]
# print(list1 + list2)
"""
9.使用切片操作，获取`list1` 第三个元素到第五个元素（包含第五个元素）。
"""
# print(list1[2:5])
"""
10. 将`list1` 的第三个元素修改为两个新元素 `13, 14]`（不是列表中的一个列表，而是将两个新元素插入到指定位置）。
"""
# list1.insert(2,13)
# list1.insert(2,14)
# print(list1)


#   进阶
# 给定初始列表
# `my_list = [3, "apple", 9, "banana", 7, "cherry", 2, "date", 5, "elderberry"]`，
# 执行以下操作：
"""
1. 向my_list中添加一个元素"fig"。
"""
# my_list = [3, "apple", 9, "banana", 7, "cherry", 2, "date", 5, "elderberry"]
# my_list.append("fig")
# print(my_list)
"""
2. 从my_list中删除元素"banana"。
"""
# my_list.remove("banana")
# print(my_list)
"""
3. 将元素7修改为字符串"grape"。
"""
# my_list[my_list.index(7)] = "grape"
# print(my_list)
"""
4.查找并打印元素"cherry"的索引值。
"""
# print(my_list.index("cherry"))
"""
5.遍历my_list并打印每个元素。
"""
# for i in my_list:
#     print(i)
"""
6.在"cherry"后面插入新元素"kiwi"。
"""
# my_list.insert(my_list.index("cherry"),"kiwi")
# print(my_list)
"""
7. 使用索引查找并打印第三个元素。
"""
# print(my_list[2])
"""
8. 使用负数索引找到并打印倒数第二个元素。
"""
# print(my_list[-2])
"""
9. 使用切片操作获取第三个至第七个元素并打印结果。
"""
# print(my_list[2:6])
"""
10. 使用切片操作反转整个列表并打印结果。
"""
# print(my_list[::-1])
"""
11. 对列表中的字符串进行排序，并保留数字在原位。
"""
# print(my_list)
# strings = []
# for item in my_list:
#     if type(item) == str:
#         strings.append(item)
# strings.sort()
# result = []
# str_idx = 0
# for item in my_list:
#     if type(item) == str:
#         result.append(strings[str_idx])
#         str_idx += 1
#     else:
#         result.append(item)
# print(result)

"""
12.将my_list中的数字替换为它们对应的字符串形式（如1->'one'），不改变列表中原有的字符串。
"""
# 第一种
# print(my_list)
# my_list[my_list.index(3)] = "three"
# my_list[my_list.index(9)] = "nine"
# my_list[my_list.index(2)] = "two"
# my_list[my_list.index(5)] = "five"
# print(my_list)
# 第二种  调用inflect函数
# print(my_list)
# import inflect
# p = inflect.engine()
# result = []
# for item in my_list:
#     if isinstance(item,int):
#         word = p.number_to_words(item)
#         result.append(word)
#     else:
#         result.append(item)
#
# print(result)


#  复杂
"""
1. 创建一个列表包含从1到100的所有偶数。
"""
# 第一种
# li = []
# for i in range(2,101,2):
#     li.append(i)
# print(li)

#  第二种
# i = list(range(2,101,2))
# print(i)
"""
2. 将上述列表中所有偶数替换为它们的平方。
"""
# li = list(range(2,101,2))
#
# for i in range(len(li)):
#     current = li[i]
    # print(current)
#
#     li[i] = current ** 2
# print(li)

"""
3. 从上述列表中删除所有大于1000的数字。
"""
# li1 = list(range(2,101,2))
# for i in range(len(li1)):
#     current = li1[i]
#     li1[i] = current ** 2
# print(li1)

# li2 = []
# for j in li1:
#     if j <= 1000:
#         li2.append(j)
# print(li2)

"""
4. 将列表逆序。
"""
# li2.reverse()
# print(li2)
""" 如果结果输出None，是因为reverse()方法没有返回值  
 reverse()方法具有特殊的行为：
 它会直接修改原列表，使列表逆序，但不会返回新的列表，而是返回None。
"""

"""
5. 使用切片操作取出列表中的前10个元素。
"""
# li = list(range(2,101,2))
# print(li[:10])
"""
6.将一个新列表`[101, 102, 103]`加到现有列表的末尾。
"""
# li = list(range(2,101,2))
# new_li = [101,102,103]
# print(li + new_li)

"""
7. 计算列表中元素的平均值。
"""

# li = list(range(2,101,2))
# total_sum = sum(li)
# avg_sum = total_sum / len(li)
# print(avg_sum)

"""
8. 找到列表中的最大值和最小值
"""
# li = list(range(2,101,2))
# print(max(li))
# print(min(li))
"""
9. 找出列表中第一次出现的11的索引位置
"""
# li = list(range(2,101,2))
# print(li.index(11))
"""
10. 用循环遍历列表，把每个数字替换为其对应的字符形式（例如：1替换为'1'）。
注意使用不同类型的循环来实现。
"""
# li = list(range(2,101,2))
#
# li1 = []
# for i in range(len(li)):
#
#     li1.append(str(li[i]))
#
# print(li1)
"""
11. 将列表中的所有元素转换成浮点数形式。
"""
# li = list(range(2,101,2))
#
# li1 = []
#
# for i in range(len(li)):
#     li1.append(float(li[i]))
#
# print(li1)
"""
12. 找出列表中所有大于50的元素个数。
"""
# li = list(range(2,101,2))
# li1 = []
# for i in li:
#     if i <= 50:
#        li1.append(i)
# print(li1)
"""
13. 在列表的第3个位置插入数字99。
"""
# li = list(range(2,101,2))
# li.insert(3,99)
# print(li)
"""
14. 删除列表中的最后一个元素。
"""
# li = list(range(2,101,2))
# # li.pop()
# # li.pop(-1)
# print(li)
"""
15. 使用列表推导式创建一个新列表，包含原列表中每个数字乘以2的结果。
"""
# li = list(range(2,101,2))
# double_li = [i * 2 for i in li]
# print(double_li)
"""
16. 将列表分成两部分，一部分是小于等于50的数，另一部分是大于50的数。
"""
# li = list(range(2,101,2))
# li1 = []
# li2 = []
#
# for i in li:
#     if i <= 50:
#         li1.append(i)
#     else:
#         li2.append(i)
#
# print(li1)
# print(li2)

"""
17. 将列表转换为一个字典，其中列表元素作为键，其在列表中的索引作为值。
"""
# li = list(range(2,101,2))
# elem_li = li
# index_li = []
# for i in range(len(li)):
#     index_li.append(i)
#
# #print(elem_li)
# #print(index_li)
# info = dict(zip(elem_li,index_li))
# print(info)
"""
18. 使用`enumerate`函数遍历列表，并打印元素及其索引。

enumerate() 是 Python 内置函数，
用于在遍历可迭代对象（如列表、元组、字符串等）时，
同时获取元素的索引和对应的值。
基本语法：enumerate(iterable, start=0)
iterable：要遍历的可迭代对象（如列表、字符串等）
start：可选参数，指定索引的起始值，默认从 0 开始
"""
# li = list(range(2,101,2))
# for index,elem in enumerate(li):
#
#     print(index,elem)

"""
19. 从列表中随机取出一个元素。

要从列表中随机取出一个元素，
可以使用 Python 标准库中的 random 模块，
random.choice() 函数专门专门用于从序列中随机选择一个元素。
random.sample(li，3)随机取出多个（3）不重复的元素
 random.choices()：允许重复取出（即可以多次取同一个元素）
"""
# import random
#
# li = list(range(0,101,2))
#
# elem = random.choice(li)
# print(elem)

"""
20. 将列表保存到一个txt文件里，每个元素占一行。
"""
# li = list(range(0,101,2))
# with open('li.txt','w') as f:
#     for elem in li:
#         f.write('{}\n'.format(elem))
# print('已将列表成功保存到li.txt文件中')